Parser event ir - #1768

Batch documentation runs now parse every file into IR first and replay
the IR of Ruby files afterwards, in the original file order. This is a
step toward resolving names against the declarations of all files
instead of the store state at parse time.

Output for Ruby-only code bases is unchanged: the replay performs the
same store mutations in the same order, only later in time. In a code
base mixing C and Ruby sources, mutations of the C parser now happen
before all Ruby mutations instead of interleaved in file order.

A single #scan call still parses and builds immediately; the server's
per-file reparse path keeps that behavior.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

A new NamespaceResolver runs before CodeObjects are built: it
simulates the lexical scopes of the IR of every Ruby file in the
batch and computes the declaration table (namespaces, constants and
module aliases) with a fixed-point iteration, because resolving one
declaration's owner can depend on the names another declaration
introduces. Each IR record is annotated with its resolved full
names: the declared class or module, the superclass, def receivers,
constant owners, include/extend targets and constant alias targets.

CodeObjectBuilder consumes the annotations and contains no name
resolution of its own. Namespaces that no file has built yet are
created ahead of the build as ignored ghosts; a ghost revives
through the same mechanism as a namespace created inside a
:stopdoc: region when some file contributes documentable contents,
and stays out of the documentation otherwise.

Resolution is a pure function of the declaration table, with two
visible consequences. Names resolve against the declarations of all
files regardless of the file order, so a superclass or mixin
declared in a file built later is found. Within one file, forward
declarations are visible as well; test expectations of
position-dependent resolution are updated.

Details ported from the single-pass behavior: a module named as a
superclass is upgraded to a class (including for the implicit
Object superclass), `class Cipher < Cipher` resolves the right-hand
side to an outer namespace rather than the class the clause is
defining, and the resolver ignores documentation suppression when
collecting declarations: those declarations still define real Ruby
constants, so they participate in name resolution.

An implicit namespace - the owner of `class B::C` when no B is
declared anywhere - is never invented while a real declaration could
resolve the name: in real Ruby such code raises NameError unless
something defined B first, so preferring a real declaration matches
every load order that works. Nested undeclared roots stay pending
until the table is stable and are then pinned as implicit namespaces,
outermost first, so that one invented namespace can serve the deeper
pendings. The kind of a namespace is tracked as class, module or
unknown; an unknown kind falls back to a module when the namespace is
created.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>